import java.util.*;

public class day5 {
    /**
     * 数学
     * JZ62 孩子们的游戏(圆圈中最后剩下的数)
     * https://www.nowcoder.com/practice/f78a359491e64a50bce2d89cff857eb6?tpId=13&tqId=11199&ru=/exam/oj
     * 对于 约瑟夫环 是存在一个公式的：F(N,M) = (F(N - 1,M) + M) % N
     */
    public int LastRemaining_Solution (int n, int m) {
        // write code here
        if(n <= 0) {
            return -1;
        }
        return (LastRemaining_Solution(n - 1,m) + m) % n;
    }


    /**
     * BFS
     * NC398 腐烂的苹果
     * https://www.nowcoder.com/practice/54ab9865ce7a45968b126d6968a77f34?tpId=196&tqId=40529&ru=/exam/oj
     */
    int[] dx = {1,-1,0,0};
    int[] dy = {0,0,1,-1};
    public int rotApple (ArrayList<ArrayList<Integer>> grid) {
        // write code here
        int n = grid.size();
        int m = grid.get(0).size();
        // 判断哪里是判断过的了，相当于是把到过的数据变为2
        boolean[][] visit = new boolean[n][m];
        // 统计每一层的都是哪些位置的值
        Queue<int[]> queue = new LinkedList<>();
        // 遍历整个grid 统计第一层的 2 的个数，放到队列中
        for(int i = 0;i < n;i++) {
            for(int j = 0;j < m;j++) {
                if(grid.get(i).get(j) == 2 && !visit[i][j]) {
                    queue.add(new int[]{i,j});
                    visit[i][j] = true;
                }
            }
        }
        int ret = 0;
        // 处理队列中的值，一层一层的往后面进行遍历
        while(!queue.isEmpty()) {
            int size = queue.size();
            while(size-- != 0) {
                // 出队列
                int[] t = queue.poll();
                // 对下标，进行 上下左右 走的处理
                int i = t[0],j = t[1];
                for(int k = 0;k < 4;k++) {
                    int x = i + dx[k],y = j + dy[k];
                    // 进行判断当前 x,y 这个位置的值是否是符合 腐烂的条件，符合就放入到队列中
                    if(x >= 0 && x < n && y >= 0 && y < m && grid.get(x).get(y) == 1 && !visit[x][y]) {
                        queue.add(new int[]{x,y});
                        visit[x][y] = true;
                    }
                }
            }
            // 每次处理完一层，就需要把ret进行+1，也就是时间，说明是传染的时间
            ret++;
        }

        // 遍历一下所有值，看是否存在1是没有处理过的
        for(int i = 0;i < n;i++) {
            for(int j = 0;j < m;j++) {
                if(grid.get(i).get(j) == 1 && !visit[i][j]) {
                    return -1;
                }
            }
        }
        // 这里为什么要减一？
        // 因为当处理队列的时候，在传染最后一层之后，这一层也是进入到队列中了，也是需要进行出队一次，那么ret就需要++，所以多了一次
        // 需要对其把这一次进行减去
        return ret - 1;
    }


    /**
     * 模拟+贪心
     * [编程题]游游的you
     * https://www.nowcoder.com/questionTerminal/cd117803b3364b218a8b3dcc498dee25
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        while(n-- != 0) {
            int a = in.nextInt(),b = in.nextInt(),c = in.nextInt();
            // 先求最大的的分的个数，从a、b、c三个数中取出最小值，
            // 那么这个最小值就是可以组成you 这个词的个数
            int x = Math.min(a,Math.min(b,c));
            // 之后对于相邻的o，需要把组成you的个数减去，之后减1，就是分数
            // 这个o的个数可能是一个负数，比如b和x相等，再减1就是负数
            System.out.println(x * 2 + Math.max(b - x - 1,0));
        }
    }
}
